home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Freeware / Adobe Air 1.5 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / effects / EffectInstance.as < prev    next >
Encoding:
Text File  |  2008-10-29  |  10.3 KB  |  378 lines
  1. package mx.effects
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.events.TimerEvent;
  6.    import flash.utils.Timer;
  7.    import flash.utils.getQualifiedClassName;
  8.    import flash.utils.getTimer;
  9.    import mx.core.UIComponent;
  10.    import mx.core.mx_internal;
  11.    import mx.effects.effectClasses.PropertyChanges;
  12.    import mx.events.EffectEvent;
  13.    import mx.events.FlexEvent;
  14.    
  15.    use namespace mx_internal;
  16.    
  17.    public class EffectInstance extends EventDispatcher implements IEffectInstance
  18.    {
  19.       mx_internal static const VERSION:String = "3.0.0.0";
  20.       
  21.       private var _hideFocusRing:Boolean;
  22.       
  23.       private var delayStartTime:Number = 0;
  24.       
  25.       mx_internal var stopRepeat:Boolean = false;
  26.       
  27.       private var playCount:int = 0;
  28.       
  29.       private var _repeatCount:int = 0;
  30.       
  31.       private var _suspendBackgroundProcessing:Boolean = false;
  32.       
  33.       mx_internal var delayTimer:Timer;
  34.       
  35.       private var _triggerEvent:Event;
  36.       
  37.       private var _effectTargetHost:IEffectTargetHost;
  38.       
  39.       mx_internal var parentCompositeEffectInstance:EffectInstance;
  40.       
  41.       mx_internal var durationExplicitlySet:Boolean = false;
  42.       
  43.       private var _effect:IEffect;
  44.       
  45.       private var _target:Object;
  46.       
  47.       mx_internal var hideOnEffectEnd:Boolean = false;
  48.       
  49.       private var _startDelay:int = 0;
  50.       
  51.       private var delayElapsedTime:Number = 0;
  52.       
  53.       private var _repeatDelay:int = 0;
  54.       
  55.       private var _propertyChanges:PropertyChanges;
  56.       
  57.       private var _duration:Number = 500;
  58.       
  59.       private var _playReversed:Boolean;
  60.       
  61.       public function EffectInstance(param1:Object)
  62.       {
  63.          super();
  64.          this.target = param1;
  65.       }
  66.       
  67.       public function get playheadTime() : Number
  68.       {
  69.          return Math.max(playCount - 1,0) * duration + Math.max(playCount - 2,0) * repeatDelay + (mx_internal::playReversed ? 0 : startDelay);
  70.       }
  71.       
  72.       public function get hideFocusRing() : Boolean
  73.       {
  74.          return _hideFocusRing;
  75.       }
  76.       
  77.       public function stop() : void
  78.       {
  79.          if(mx_internal::delayTimer)
  80.          {
  81.             mx_internal::delayTimer.reset();
  82.          }
  83.          mx_internal::stopRepeat = true;
  84.          finishEffect();
  85.       }
  86.       
  87.       public function finishEffect() : void
  88.       {
  89.          playCount = 0;
  90.          dispatchEvent(new EffectEvent(EffectEvent.EFFECT_END,false,false,this));
  91.          if(target)
  92.          {
  93.             target.dispatchEvent(new EffectEvent(EffectEvent.EFFECT_END,false,false,this));
  94.          }
  95.          if(target is UIComponent)
  96.          {
  97.             UIComponent(target).effectFinished(this);
  98.          }
  99.          EffectManager.mx_internal::effectFinished(this);
  100.       }
  101.       
  102.       public function set hideFocusRing(param1:Boolean) : void
  103.       {
  104.          _hideFocusRing = param1;
  105.       }
  106.       
  107.       public function finishRepeat() : void
  108.       {
  109.          if(!mx_internal::stopRepeat && playCount != 0 && (playCount < repeatCount || repeatCount == 0))
  110.          {
  111.             if(repeatDelay > 0)
  112.             {
  113.                mx_internal::delayTimer = new Timer(repeatDelay,1);
  114.                delayStartTime = getTimer();
  115.                mx_internal::delayTimer.addEventListener(TimerEvent.TIMER,delayTimerHandler);
  116.                mx_internal::delayTimer.start();
  117.             }
  118.             else
  119.             {
  120.                play();
  121.             }
  122.          }
  123.          else
  124.          {
  125.             finishEffect();
  126.          }
  127.       }
  128.       
  129.       mx_internal function get playReversed() : Boolean
  130.       {
  131.          return _playReversed;
  132.       }
  133.       
  134.       public function set effect(param1:IEffect) : void
  135.       {
  136.          _effect = param1;
  137.       }
  138.       
  139.       public function get className() : String
  140.       {
  141.          var _loc1_:String = getQualifiedClassName(this);
  142.          var _loc2_:int = int(_loc1_.indexOf("::"));
  143.          if(_loc2_ != -1)
  144.          {
  145.             _loc1_ = _loc1_.substr(_loc2_ + 2);
  146.          }
  147.          return _loc1_;
  148.       }
  149.       
  150.       public function set duration(param1:Number) : void
  151.       {
  152.          mx_internal::durationExplicitlySet = true;
  153.          _duration = param1;
  154.       }
  155.       
  156.       mx_internal function set playReversed(param1:Boolean) : void
  157.       {
  158.          _playReversed = param1;
  159.       }
  160.       
  161.       public function resume() : void
  162.       {
  163.          if(mx_internal::delayTimer && !mx_internal::delayTimer.running && !isNaN(delayElapsedTime))
  164.          {
  165.             mx_internal::delayTimer.delay = !mx_internal::playReversed ? mx_internal::delayTimer.delay - delayElapsedTime : delayElapsedTime;
  166.             mx_internal::delayTimer.start();
  167.          }
  168.       }
  169.       
  170.       public function get propertyChanges() : PropertyChanges
  171.       {
  172.          return _propertyChanges;
  173.       }
  174.       
  175.       public function set target(param1:Object) : void
  176.       {
  177.          _target = param1;
  178.       }
  179.       
  180.       public function get repeatCount() : int
  181.       {
  182.          return _repeatCount;
  183.       }
  184.       
  185.       mx_internal function playWithNoDuration() : void
  186.       {
  187.          duration = 0;
  188.          repeatCount = 1;
  189.          repeatDelay = 0;
  190.          startDelay = 0;
  191.          startEffect();
  192.       }
  193.       
  194.       public function get startDelay() : int
  195.       {
  196.          return _startDelay;
  197.       }
  198.       
  199.       mx_internal function get actualDuration() : Number
  200.       {
  201.          var _loc1_:Number = NaN;
  202.          if(repeatCount > 0)
  203.          {
  204.             _loc1_ = duration * repeatCount + (repeatDelay * repeatCount - 1) + startDelay;
  205.          }
  206.          return _loc1_;
  207.       }
  208.       
  209.       public function play() : void
  210.       {
  211.          ++playCount;
  212.          dispatchEvent(new EffectEvent(EffectEvent.EFFECT_START,false,false,this));
  213.          if(target)
  214.          {
  215.             target.dispatchEvent(new EffectEvent(EffectEvent.EFFECT_START,false,false,this));
  216.          }
  217.       }
  218.       
  219.       public function get suspendBackgroundProcessing() : Boolean
  220.       {
  221.          return _suspendBackgroundProcessing;
  222.       }
  223.       
  224.       public function get effectTargetHost() : IEffectTargetHost
  225.       {
  226.          return _effectTargetHost;
  227.       }
  228.       
  229.       public function set repeatDelay(param1:int) : void
  230.       {
  231.          _repeatDelay = param1;
  232.       }
  233.       
  234.       public function set propertyChanges(param1:PropertyChanges) : void
  235.       {
  236.          _propertyChanges = param1;
  237.       }
  238.       
  239.       mx_internal function eventHandler(param1:Event) : void
  240.       {
  241.          if(param1.type == FlexEvent.SHOW && mx_internal::hideOnEffectEnd == true)
  242.          {
  243.             mx_internal::hideOnEffectEnd = false;
  244.             param1.target.removeEventListener(FlexEvent.SHOW,mx_internal::eventHandler);
  245.          }
  246.       }
  247.       
  248.       public function set repeatCount(param1:int) : void
  249.       {
  250.          _repeatCount = param1;
  251.       }
  252.       
  253.       private function delayTimerHandler(param1:TimerEvent) : void
  254.       {
  255.          mx_internal::delayTimer.reset();
  256.          delayStartTime = NaN;
  257.          delayElapsedTime = NaN;
  258.          play();
  259.       }
  260.       
  261.       public function set suspendBackgroundProcessing(param1:Boolean) : void
  262.       {
  263.          _suspendBackgroundProcessing = param1;
  264.       }
  265.       
  266.       public function set triggerEvent(param1:Event) : void
  267.       {
  268.          _triggerEvent = param1;
  269.       }
  270.       
  271.       public function set startDelay(param1:int) : void
  272.       {
  273.          _startDelay = param1;
  274.       }
  275.       
  276.       public function get effect() : IEffect
  277.       {
  278.          return _effect;
  279.       }
  280.       
  281.       public function set effectTargetHost(param1:IEffectTargetHost) : void
  282.       {
  283.          _effectTargetHost = param1;
  284.       }
  285.       
  286.       public function get target() : Object
  287.       {
  288.          return _target;
  289.       }
  290.       
  291.       public function startEffect() : void
  292.       {
  293.          EffectManager.mx_internal::effectStarted(this);
  294.          if(target is UIComponent)
  295.          {
  296.             UIComponent(target).effectStarted(this);
  297.          }
  298.          if(startDelay > 0 && !mx_internal::playReversed)
  299.          {
  300.             mx_internal::delayTimer = new Timer(startDelay,1);
  301.             delayStartTime = getTimer();
  302.             mx_internal::delayTimer.addEventListener(TimerEvent.TIMER,delayTimerHandler);
  303.             mx_internal::delayTimer.start();
  304.          }
  305.          else
  306.          {
  307.             play();
  308.          }
  309.       }
  310.       
  311.       public function get repeatDelay() : int
  312.       {
  313.          return _repeatDelay;
  314.       }
  315.       
  316.       public function get duration() : Number
  317.       {
  318.          if(!mx_internal::durationExplicitlySet && Boolean(mx_internal::parentCompositeEffectInstance))
  319.          {
  320.             return mx_internal::parentCompositeEffectInstance.duration;
  321.          }
  322.          return _duration;
  323.       }
  324.       
  325.       public function initEffect(param1:Event) : void
  326.       {
  327.          triggerEvent = param1;
  328.          switch(param1.type)
  329.          {
  330.             case "resizeStart":
  331.             case "resizeEnd":
  332.                if(!mx_internal::durationExplicitlySet)
  333.                {
  334.                   duration = 250;
  335.                }
  336.                break;
  337.             case FlexEvent.HIDE:
  338.                target.setVisible(true,true);
  339.                mx_internal::hideOnEffectEnd = true;
  340.                target.addEventListener(FlexEvent.SHOW,mx_internal::eventHandler);
  341.          }
  342.       }
  343.       
  344.       public function get triggerEvent() : Event
  345.       {
  346.          return _triggerEvent;
  347.       }
  348.       
  349.       public function end() : void
  350.       {
  351.          if(mx_internal::delayTimer)
  352.          {
  353.             mx_internal::delayTimer.reset();
  354.          }
  355.          mx_internal::stopRepeat = true;
  356.          finishEffect();
  357.       }
  358.       
  359.       public function reverse() : void
  360.       {
  361.          if(repeatCount > 0)
  362.          {
  363.             playCount = repeatCount - playCount + 1;
  364.          }
  365.       }
  366.       
  367.       public function pause() : void
  368.       {
  369.          if(mx_internal::delayTimer && mx_internal::delayTimer.running && !isNaN(delayStartTime))
  370.          {
  371.             mx_internal::delayTimer.stop();
  372.             delayElapsedTime = getTimer() - delayStartTime;
  373.          }
  374.       }
  375.    }
  376. }
  377.  
  378.